src/Consolonia.Core/Controls/FolderPicker.axaml.cs (3)

10-15: Add XML documentation for public members.

As this is a public class, adding XML documentation would improve API discoverability and usage understanding.

+    /// <summary>
+    /// A dialog window that allows users to select one or multiple folders.
+    /// </summary>
     public partial class FolderPicker : DialogWindow
     {
+        /// <summary>
+        /// Initializes a new instance of the FolderPicker with default options.
+        /// </summary>
         public FolderPicker()
             : this(new FolderPickerOpenOptions())
         {
         }

---

48-56: Add error handling to dialog operations.

The OK and Cancel handlers should include error handling for the dialog operations.

     private void OnOK(object sender, RoutedEventArgs e)
     {
+        try
+        {
             CloseDialog(ViewModel.SelectedFolders);
+        }
+        catch (Exception ex)
+        {
+            // Log error and show user-friendly message
+            // Logger.LogError(ex, "Failed to close dialog with selection");
+        }
     }

     private void OnCancel(object sender, RoutedEventArgs e)
     {
+        try
+        {
             CloseDialog();
+        }
+        catch (Exception ex)
+        {
+            // Log error and show user-friendly message
+            // Logger.LogError(ex, "Failed to cancel dialog");
+        }
     }

---

58-81: Refactor ListBox_SelectionChanged for better maintainability.

The selection changed handler is complex and could benefit from being split into smaller, more focused methods.

     private void ListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
     {
+        try
+        {
-            if (ViewModel.SelectionMode == SelectionMode.Single)
-            {
-                if (e.AddedItems.Count > 0 &&
-                    e.AddedItems[0] is IStorageFolder folder)
-                {
-                    ViewModel.SelectedFolders.Clear();
-                    ViewModel.SelectedFolders.Add(folder);
-                }
-            }
-            else
-            {
-                foreach (object item in e.AddedItems)
-                    if (item is IStorageFolder folder)
-                        ViewModel.SelectedFolders.Add(folder);
-
-                foreach (object item in e.RemovedItems)
-                    if (item is IStorageFolder folder)
-                        ViewModel.SelectedFolders.Remove(folder);
-            }
+            UpdateSelection(e);
+            UpdateSelectionState();
+        }
+        catch (Exception ex)
+        {
+            // Log error and show user-friendly message
+            // Logger.LogError(ex, "Failed to update selection");
+        }
+    }

-            ViewModel.HasSelection = ViewModel.SelectedFolders.Count > 0;
+    private void UpdateSelection(SelectionChangedEventArgs e)
+    {
+        if (ViewModel.SelectionMode == SelectionMode.Single)
+        {
+            HandleSingleSelection(e.AddedItems);
+        }
+        else
+        {
+            HandleMultiSelection(e.AddedItems, e.RemovedItems);
+        }
+    }
+
+    private void HandleSingleSelection(IList addedItems)
+    {
+        if (addedItems.Count > 0 && addedItems[0] is IStorageFolder folder)
+        {
+            ViewModel.SelectedFolders.Clear();
+            ViewModel.SelectedFolders.Add(folder);
+        }
+    }
+
+    private void HandleMultiSelection(IList addedItems, IList removedItems)
+    {
+        foreach (var folder in addedItems.OfType<IStorageFolder>())
+        {
+            ViewModel.SelectedFolders.Add(folder);
+        }
+
+        foreach (var folder in removedItems.OfType<IStorageFolder>())
+        {
+            ViewModel.SelectedFolders.Remove(folder);
+        }
+    }
+
+    private void UpdateSelectionState()
+    {
+        ViewModel.HasSelection = ViewModel.SelectedFolders.Count > 0;
     }

src/Consolonia.Core/Controls/MessageBox.axaml.cs (4)

10-123: Add XML documentation comments to public members

To enhance maintainability and improve developer experience, consider adding XML documentation comments to public classes, methods, properties, and enums. This will aid in generating API documentation and provide better IntelliSense support.

---

88-96: Handle potential null values for 'text' and 'title' parameters

In the ShowDialogAsync method, if text or title is null, it might lead to unexpected behavior or exceptions in the dialog display. Consider validating these parameters or ensuring that the MessageBoxViewModel handles null values appropriately.

---

91-95: Consider enabling nullable reference types at the project level

Instead of enabling #nullable enable within a specific method, consider enabling nullable reference types at the project or file level. This provides consistent nullability analysis across the codebase and helps prevent null-related issues.

---

156-211: Consider sealing the 'MessageBoxViewModel' class

If MessageBoxViewModel is not intended for inheritance, marking it as sealed can prevent unintended subclassing and allow for potential performance optimizations.

Configuration used: CodeRabbit UI
Review profile: CHILL

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryComboBox.axaml.cs (1)

19-19: Add error handling for empty environment variables list.

Setting SelectedIndex = 0 without checking if the list is empty could cause an exception.

Consider adding a null check:

-            VarsComboBox.SelectedIndex = 0;
+            if (VarsComboBox.ItemsSource?.Cast<object>().Any() == true)
+                VarsComboBox.SelectedIndex = 0;

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryCalendar.axaml.cs (1)

Line range hint 13-18: Add bounds checking for date calculations

The date calculations (AddDays) could potentially overflow if the values are near DateTime bounds. Consider adding validation:

-            cal1.DisplayDateStart = today.AddDays(-25);
-            cal1.DisplayDateEnd = today.AddDays(25);
+            // Ensure date calculations don't overflow
+            if (today > DateTime.MinValue.AddDays(25) && today < DateTime.MaxValue.AddDays(-25))
+            {
+                cal1.DisplayDateStart = today.AddDays(-25);
+                cal1.DisplayDateEnd = today.AddDays(25);
+            }
+            else
+            {
+                // Handle edge case or log warning
+                cal1.DisplayDateStart = today;
+                cal1.DisplayDateEnd = today;
+            }

src/Example/Views/DataGridTestWindow.axaml.cs (1)

46-49: Consider adding null checks and improving error handling.

While the event handler follows proper naming conventions, the casting could be more defensive:

-private void Delete_Clicked(object sender, RoutedEventArgs _)
-{
-    _items.Remove((TheItem)((Control)sender).DataContext);
-}
+private void Delete_Clicked(object sender, RoutedEventArgs _)
+{
+    if (sender is Control control && control.DataContext is TheItem item)
+    {
+        _items.Remove(item);
+    }
+}

Also, consider addressing the TODO comment about the ReSharper rule suppression.

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryCalendarPicker.axaml.cs (4)

Line range hint 16-19: Consider using XAML bindings instead of direct control references

Retrieving controls by string IDs is fragile and error-prone. Consider:

1. Using proper XAML bindings to view model properties
2. Using x:Name references if direct access is necessary

---

Line range hint 21-23: Move date initialization to view model

Setting dates directly in the control's constructor violates MVVM principles. Consider:

1. Moving these default values to the view model
2. Using XAML bindings to connect the view model properties to the CalendarDatePicker controls

---

Line range hint 25-25: Consider moving blackout dates logic to view model

The blackout dates configuration is UI logic that could be better managed in the view model:

1. It would improve testability
2. It would make the behavior more maintainable

---

Line range hint 1-54: Consider restructuring to better follow MVVM pattern

The current implementation mixes view and view model concerns. Consider:

1. Moving all date manipulation logic to the view model
2. Using XAML bindings for control properties
3. Creating a dedicated interface for the view model
4. Adding commands for user interactions

This would improve:

• Testability
• Maintainability
• Separation of concerns

src/Consolonia.Gallery/View/ControlsListView.axaml.cs (1)

32-32: Consider adding null check for Grid property.

The changes to use this.Grid directly are good, but consider adding a null check for defensive programming.

 private void TrySetupSelected()
 {
+    if (this.Grid == null)
+        throw new InvalidOperationException("Grid control not initialized");
+
     if (_commandLineArgs.Length is not 1 and not 2)
     {
         this.Grid.SelectedIndex = 0;
         return;
     }

Also applies to: 52-53

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryGradientBrush.axaml.cs (4)

Line range hint 9-12: Fix initialization after InitializeComponent removal

The constructor still calls InitializeComponent() but according to the summary, this method has been removed. This will cause a compilation error.

Apply this diff to fix the initialization:

 public GalleryGradientBrush()
 {
-    InitializeComponent();
 }

---

Line range hint 30-40: Add null check for consistency

For consistency with the previous suggestion, consider adding a null check here as well.

Apply this diff:

 private void Radial_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
 {
+    if (MyGrid == null) return;
     this.MyGrid.Background = new RadialGradientBrush

---

43-44: Remove extra blank line

There's an extra blank line that affects code formatting consistency.

         }
-
         private void Conic_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)

---

Line range hint 45-58: Add null check for consistency

For consistency with the previous suggestions, consider adding a null check here as well.

Apply this diff:

 private void Conic_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
 {
+    if (MyGrid == null) return;
     this.MyGrid.Background = new ConicGradientBrush

src/Consolonia.Core/Controls/Dialog/DialogWrap.axaml.cs (2)

Line range hint 25-39: Consider potential memory leak in event subscription

The AttachedToVisualTree handler creates a new subscription each time it fires, but the previous subscription is only disposed when the control is detached. This could lead to multiple active subscriptions if the control is repeatedly attached without being detached.

Consider this safer implementation:

  AttachedToVisualTree += (_, _) =>
  {
+     _disposable?.Dispose();
      var parentWindow = this.FindAncestorOfType<Window>();
      _disposable = parentWindow!.GetPropertyChangedObservable(TopLevel.ClientSizeProperty).Subscribe(
          new AnonymousObserver<AvaloniaPropertyChangedEventArgs>(
              args =>
              {
                  var newSize = (Size)args.NewValue!;
                  SetNewSize(newSize);
              }));
      SetNewSize(parentWindow!.ClientSize);
  };

---

Line range hint 63-67: Reconsider commented code retention

The CloseDialog method is marked as unused and suppressed with pragmas, kept only as an example for future mouse support. Consider either:

1. Removing it and tracking the requirement in documentation/issues
2. Implementing it now if mouse support is planned soon

If keeping it for documentation purposes, consider improving the comment:

- // ReSharper disable once UnusedMember.Local Example of usage for further (when mouse support introduced for example)
+ /// <summary>
+ /// Reserved for future mouse support implementation.
+ /// This method will handle dialog closure triggered by mouse interactions.
+ /// </summary>

src/Consolonia.Core/Controls/FolderPicker.axaml.cs (1)

1-77: Consider implementing MVVM pattern more strictly.

The current implementation has tight coupling between the view and view model through direct property access. Consider:

1. Using commands instead of event handlers
2. Implementing proper data binding
3. Moving selection logic to the view model

This would improve testability and maintainability. For example:

+ // In ViewModel
+ public ICommand SelectFolderCommand { get; }
+ public ICommand CancelCommand { get; }
+ public ICommand UpdateSelectionCommand { get; }

+ // In View
- private void OnOK(object sender, RoutedEventArgs e)
- {
-     CloseDialog(ViewModel.SelectedFolders);
- }
+ <Button Command="{Binding SelectFolderCommand}" />

Would you like assistance in implementing these architectural improvements?

src/Example/Views/DataGridTestWindow.axaml (1)

Line range hint 8-106: Consider enhancing accessibility with ARIA labels.

While the UI has good keyboard navigation support, consider adding aria-label attributes to improve accessibility for screen readers, particularly for the data grid and action buttons.

Add aria labels to key interactive elements:

             <DataGrid ItemsSource="{Binding}"
                      Name="Grid"
                      SelectionMode="Single"
                      Focusable="True"
                      AutoGenerateColumns="False"
+                     AutomationProperties.Name="Movie Catalog Grid"
                      HorizontalScrollBarVisibility="Disabled">

             <!-- ... -->

             <Button Content="Delete"
                     Grid.Row="4"
                     Grid.ColumnSpan="2"
                     Grid.Column="0"
                     HorizontalAlignment="Center"
+                    AutomationProperties.Name="Delete Selected Movie"
                     Click="Delete_Clicked" />

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryDataGrid.axaml.cs (2)

Line range hint 32-43: Consider simplifying the sorting logic

The sorting logic in the event handler could be simplified and made more maintainable.

Consider this refactoring:

-DataGrid1.Sorting += (_, a) =>
-{
-    var binding = (a.Column as DataGridBoundColumn)?.Binding as Binding;
-
-    if (binding?.Path is { } property
-        && property == dataGridSortDescription.PropertyPath
-        && !collectionView1.SortDescriptions.Contains(dataGridSortDescription))
-        collectionView1.SortDescriptions.Add(dataGridSortDescription);
-};
+DataGrid1.Sorting += (_, args) =>
+{
+    if (args.Column is DataGridBoundColumn { Binding: Binding binding } 
+        && binding.Path == dataGridSortDescription.PropertyPath
+        && !collectionView1.SortDescriptions.Contains(dataGridSortDescription))
+    {
+        collectionView1.SortDescriptions.Add(dataGridSortDescription);
+    }
+};

---

Line range hint 52-62: Consider separating sample data and adding error handling

The current implementation could be improved in terms of separation of concerns and error handling.

1. Move the sample data to a separate method or service:

+private static List<Person> GetSamplePersons()
+{
+    return new List<Person>
+    {
+        new() { FirstName = "John", LastName = "Doe" },
+        new() { FirstName = "Elizabeth", LastName = "Thomas", IsBanned = true },
+        new() { FirstName = "Zack", LastName = "Ward" }
+    };
+}

2. Add error handling to the Add button click handler:

-BtnAdd.Click += (_, _) => collectionView3.AddNew();
+BtnAdd.Click += (_, _) =>
+{
+    try
+    {
+        collectionView3.AddNew();
+    }
+    catch (Exception ex)
+    {
+        // Handle or log the error appropriately
+        Debug.WriteLine($"Failed to add new item: {ex.Message}");
+    }
+};

src/Consolonia.Core/Controls/MessageBox.axaml.cs (2)

56-66: Add XML documentation comments to public properties and methods

To improve code maintainability and assist developers using this class, consider adding XML documentation comments to all public properties and methods.

For example:

+/// <summary>
+/// Gets or sets the message box mode, which determines the buttons displayed.
+/// </summary>
 public Mode Mode
 {
     get => _mode;
     set => SetAndRaise(ModeProperty, ref _mode, value);
 }

Also applies to: 68-84, 86-94

---

9-9: Remove partial modifier if not required

The classes MessageBox and MessageBoxViewModel are declared with the partial keyword, but there are no other partial class definitions provided. If these classes are not split across multiple files, consider removing the partial modifier for clarity.

Apply this change:

-public partial class MessageBox : DialogWindow
+public class MessageBox : DialogWindow

-internal partial class MessageBoxViewModel : ObservableObject
+internal class MessageBoxViewModel : ObservableObject

Also applies to: 148-148

Configuration used: CodeRabbit UI
Review profile: CHILL

#!/bin/bash
# Description: Verify calendar control IDs exist in the corresponding XAML file
# Expected: Should find both control IDs in the XAML

rg -l "DisplayDatesCalendar|BlackoutDatesCalendar" --type xaml "src/Consolonia.Gallery/Gallery/GalleryViews/GalleryCalendar.axaml"

#!/bin/bash
# Let's try searching without file type restriction since .xaml might not be recognized
rg -l "DisplayDatesCalendar|BlackoutDatesCalendar" "src/Consolonia.Gallery/Gallery/GalleryViews/GalleryCalendar.axaml"

# Also let's verify if the file exists and see its content
fd "GalleryCalendar.axaml" && cat src/Consolonia.Gallery/Gallery/GalleryViews/GalleryCalendar.axaml

 private void Linear_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
 {
+    if (MyGrid == null) return;
     this.MyGrid.Background = new LinearGradientBrush

 private void Linear_Click(object sender, Avalonia.Interactivity.RoutedEventArgs e)
 {
+    if (MyGrid == null) return;
     this.MyGrid.Background = new LinearGradientBrush

#!/bin/bash
# Description: Verify MyGrid property generation in XAML
# Look for x:Name="MyGrid" in the corresponding XAML file

fd -e axaml "GalleryGradientBrush.axaml$" -x cat {} | grep -A 5 'x:Name="MyGrid"'

#!/bin/bash
# Let's verify if the code is using Avalonia's code generation by checking for the presence of g.cs files
fd -e g.cs . -x cat {} | grep -A 5 "MyGrid"

# Also check if there are any other usages of MyGrid in the codebase
rg "MyGrid" -A 3 -B 3

#!/bin/bash
# Let's check if this is an Avalonia project and verify the code generation setup
fd "GalleryGradientBrush" -e csproj -x cat {}

# Also check the base class of GalleryGradientBrush to understand the code generation pattern
rg "class GalleryGradientBrush" -A 2

#!/bin/bash
# Description: Check for remaining FindControl usage in other files
# Look for any remaining FindControl patterns that might have been missed

# Search for FindControl usage
echo "Files still using FindControl:"
rg "FindControl<\w+>\(" --type cs

# Search for InitializeComponent calls
echo -e "\nFiles still calling InitializeComponent:"
rg "InitializeComponent\(\)" --type cs

#!/bin/bash
# Check for MyGrid usage pattern in XAML and code files
echo "Checking MyGrid usage in XAML files:"
rg "Name=\"MyGrid\"" --type xaml

echo -e "\nChecking direct property access patterns similar to 'this.MyGrid' in cs files:"
rg "this\.\w+\.(Background|Content|Children)" --type cs -A 2

echo -e "\nChecking XAML files with x:Name properties:"
rg "x:Name=\"\w+\"" --type xaml

#!/bin/bash
# Search for .axaml files and their content
echo "Checking .axaml files content:"
fd -e axaml -x cat {}

echo -e "\nChecking for any remaining FindControl patterns in the codebase:"
rg -i "findcontrol" --type-add 'cs:*.{cs,axaml}' --type cs -A 2

#!/bin/bash
# Check for corresponding XAML file
fd "DialogWrap.axaml$"

# Check if other dialog controls follow the same pattern
ast-grep --pattern 'class $_ : UserControl { 
  $$$
  InitializeComponent();
  $$$
}'

#!/bin/bash
# Check the content of the XAML file
cat src/Consolonia.Core/Controls/Dialog/DialogWrap.axaml

# Check if there are any build configurations related to XAML
fd ".*proj$" | xargs grep -l "AvaloniaXaml"

# Check for any base class or interface implementations
ast-grep --pattern 'class DialogWrap : $_ {
  $$$
}'

#!/bin/bash
# Search for any remaining references to the old namespace
rg "Consolonia\.Themes\.TurboVision\.Templates\.Controls\.DialogWrap" 

# Search for existing usages that might need updating
rg "using.*DialogWrap" 

#!/bin/bash
# Let's try a broader search for DialogWrap references
rg "DialogWrap" -l

# Search for any imports or using statements containing Dialog
rg "using.*Dialog" 

# Look for XAML files that might reference DialogWrap
fd -e xaml -x grep -l "DialogWrap" {}

# Check git diff to see the changes in namespace usage
git diff origin/main -- "**/DialogWrap*"

#!/bin/bash
# Description: Check if the code-behind file has the updated method name

# Find and check the content of the code-behind file
rg -l "DataGridTestWindow\.axaml\.cs$" | xargs rg "Delete_Clicked|delete_Clicked"

src/Consolonia.Core/Controls/DialogWindow.cs (2)

75-111: Remove or implement commented Position property

The Position property is commented out but includes implementation details. Either implement it if needed or remove it completely to maintain clean code.

-        /// <summary>
-        ///     Gets or sets the window position in screen coordinates.
-        /// </summary>
-        //public PixelPoint Position
-        //{
-        //    get => PlatformImpl?.Position ?? PixelPoint.Origin;
-        //    set => PlatformImpl?.Move(value);
-        //}

---

Line range hint 187-192: Add null check in GetDialogHost method

The use of null-forgiving operator (!.) might hide potential null reference issues.

 protected static DialogHost GetDialogHost(Visual parent)
 {
     var window = parent.FindAncestorOfType<Window>(true);
+    if (window == null)
+        throw new InvalidOperationException("Dialog must be hosted within a Window.");
-    DialogHost dialogHost = window!.GetValue(DialogHost.DialogHostProperty);
+    DialogHost dialogHost = window.GetValue(DialogHost.DialogHostProperty);
+    if (dialogHost == null)
+        throw new InvalidOperationException("Window must have a DialogHost registered.");
     return dialogHost;
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

Learnt from: tomlm
PR: jinek/Consolonia#153
File: src/Consolonia.Core/Controls/DialogWindow.cs:136-141
Timestamp: 2024-11-25T06:18:08.175Z
Learning: In the `DialogWindow` class (`src/Consolonia.Core/Controls/DialogWindow.cs`), casting `Width` and `Height` to `ushort` is intentional and should not be flagged as an issue.

 public virtual void CloseDialog(object result = null)
 {
     DialogHost dialogHost = GetDialogHost(this);
     dialogHost.PopInternal(this);
     if (Parent is Window window) window.SizeChanged -= Window_SizeChanged;
-    _taskCompletionSource.SetResult(result);
+    _taskCompletionSource?.SetResult(result);
 }

-private TaskCompletionSource<object> _taskCompletionSource;
+private TaskCompletionSource _taskCompletionSource;
+private Type _expectedResultType;

+protected void SetDialogResult<T>(T result)
+{
+    if (_taskCompletionSource == null)
+        throw new InvalidOperationException("Dialog is not shown.");
+        
+    if (result != null && !_expectedResultType.IsAssignableFrom(result.GetType()))
+        throw new InvalidCastException($"Result type {result.GetType()} is not assignable to expected type {_expectedResultType}");
+        
+    ((TaskCompletionSource<T>)_taskCompletionSource).SetResult(result);
+}

 public async Task<T> ShowDialogAsync<T>(Control parent)
 {
     if (_taskCompletionSource != null)
         throw new InvalidOperationException("Dialog is already shown.");

-    _taskCompletionSource = new TaskCompletionSource<object>();
+    _taskCompletionSource = new TaskCompletionSource<T>();
+    _expectedResultType = typeof(T);
     ShowDialogInternal(parent);
-    object result = await _taskCompletionSource.Task;
-    return (T)result;
+    return await ((TaskCompletionSource<T>)_taskCompletionSource).Task;
 }

src/Consolonia.Core/Controls/MessageBox.axaml.cs (4)

1-1: Remove unused using directives.

The using directives using System; and using Avalonia.Input; are not required and can be safely removed to clean up the code.

Apply this diff to remove the unused directives:

-using System;
...
-using Avalonia.Input;

Also applies to: 5-5

🧰 Tools

🪛 GitHub Check: build

[warning] 1-1:
"[RedundantUsingDirective] Using directive is not required by the code and can be safely removed" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(1,1)

---

48-48: Remove redundant 'this.' qualifier.

The this. qualifier is redundant here and can be omitted for cleaner code.

Apply this diff:

-             this.AttachedToVisualTree += (s, e) =>
+             AttachedToVisualTree += (s, e) =>

🧰 Tools

🪛 GitHub Check: build

[notice] 48-48:
"[ArrangeThisQualifier] Qualifier 'this.' is redundant" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,13)

---

[warning] 48-48:
"[UnusedParameter.Local] Parameter 'e' is never used" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,46)

---

[warning] 48-48:
"[UnusedParameter.Local] Parameter 's' is never used" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,43)

---

48-48: Rename unused parameters to underscores to indicate they are unused.

The parameters s, e, s2, and e2 are unused in the lambda expressions. Renaming them to _ clarifies that they are intentionally unused.

Apply this diff:

-             AttachedToVisualTree += (s, e) =>
+             AttachedToVisualTree += (_, _) =>

              {
-                 if (OkButton.IsVisible)
-                     OkButton.AttachedToVisualTree += (s2, e2) => OkButton.Focus();
+                 if (OkButton.IsVisible)
+                     OkButton.AttachedToVisualTree += (_, _) => OkButton.Focus();
                  else if (YesButton.IsVisible)
-                     YesButton.AttachedToVisualTree += (s2, e2) => YesButton.Focus();
+                     YesButton.AttachedToVisualTree += (_, _) => YesButton.Focus();
                  else if (CancelButton.IsVisible)
-                     CancelButton.AttachedToVisualTree += (s2, e2) => CancelButton.Focus();
+                     CancelButton.AttachedToVisualTree += (_, _) => CancelButton.Focus();
                  else if (NoButton.IsVisible)
-                     NoButton.AttachedToVisualTree += (s2, e2) => NoButton.Focus();
+                     NoButton.AttachedToVisualTree += (_, _) => NoButton.Focus();
              };

Also applies to: 51-51, 53-53, 55-55, 57-57

🧰 Tools

🪛 GitHub Check: build

[notice] 48-48:
"[ArrangeThisQualifier] Qualifier 'this.' is redundant" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,13)

---

[warning] 48-48:
"[UnusedParameter.Local] Parameter 'e' is never used" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,46)

---

[warning] 48-48:
"[UnusedParameter.Local] Parameter 's' is never used" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(48,43)

---

95-97: Simplify null-check and return statement with null-coalescing operator.

The null-check can be simplified using the null-coalescing operator ?? for cleaner code.

Apply this diff:

  var result = await ShowDialogAsync<MessageBoxResult?>(parent);
- if (result.HasValue) return result.Value;
- return MessageBoxResult.Cancel;
+ return result ?? MessageBoxResult.Cancel;

🧰 Tools

🪛 GitHub Check: build

[notice] 96-96:
"[ConvertIfStatementToReturnStatement] Convert into 'return' statement" on /home/runner/work/Consolonia/Consolonia/src/Consolonia.Core/Controls/MessageBox.axaml.cs(96,13)

Configuration used: CodeRabbit UI
Review profile: CHILL

src/Consolonia.Core/Controls/MessageBox.axaml.cs (2)

153-153: Remove the partial keyword from MessageBoxViewModel if not required

The MessageBoxViewModel class is declared as an internal partial class. If there are no other partial definitions of this class elsewhere in the codebase, the partial keyword is unnecessary and can be removed for clarity.

---

11-27: Specify a more precise type for button content properties

The properties Ok, Cancel, Yes, and No are currently of type object. If these properties are intended to hold specific types of content, such as string or a specific control type, consider specifying a more precise type to improve type safety and readability.

Also applies to: 67-89

Configuration used: CodeRabbit UI
Review profile: CHILL

Directory.Build.props (2)

12-12: Consider a more targeted warning suppression approach.

Global warning suppression in Directory.Build.props affects all projects in the solution. Consider:

1. Moving this to specific project files where the warning is relevant
2. Using #pragma warning disable in specific code files
3. Documenting why this warning needs to be suppressed

This helps maintain better visibility of potential issues and keeps warning suppression scoped to where it's needed.

---

Line range hint 3-3: Track the TODO comment about mono support.

The TODO comment about adding mono support should be tracked to ensure it's not forgotten.

Would you like me to create a GitHub issue to track the mono support implementation?

Configuration used: CodeRabbit UI
Review profile: CHILL